"""
名称	        说明
os	            多种操作系统接口。
sys	            系统相关的形参和函数。
time	        时间的访问和转换。
datetime	    提供了用于操作日期和时间的类。
math	        数学函数。
random	        生成伪随机数。
re	            正则表达式匹配操作。
json	        JSON 编码器和解码器。
collections	    实现了一些专门化的容器，提供了对 Python 的通用内建容器 dict、list、set 和 tuple 的补充。
functools	    高阶函数，以及可调用对象上的操作
hashlib	        安全哈希与消息摘要。
urllib	        URL 处理模块。
smtplib	SMTP    协议客户端，邮件处理。
zlib	        与 gzip 兼容的压缩。
gzip	        对 gzip 文件的支持。
bz2	            对 bzip2 压缩算法的支持。
multiprocessing	基于进程的并行。
threading	    基于线程的并行。
copy	        浅层及深层拷贝操作。
socket	        低层级的网络接口。
shutil	        提供了一系列对文件和文件集合的高阶操作，特别是提供了一些支持文件拷贝和删除的函数。
glob	        Unix 风格的路径名模式扩展。

更多标准库可参考https://docs.python.org/zh-cn/3/library/index.html。
"""
# ...existing code...
"""
下面为每个包列出常用约 10 个方法/属性，并给出简短示例与注释（示例均为单行，不对外部资源执行实际网络/文件写入等操作）。
注：示例主要为说明用法，实际使用时请根据场景处理异常与资源释放。

os:
    import os
    os.listdir('.')                 # 列出目录下文件/子目录
    os.scandir('.')                 # 推荐的目录迭代器，效率高
    os.mkdir('dir')                 # 创建单个目录
    os.makedirs('a/b/c', exist_ok=True)  # 递归创建目录
    os.remove('file.txt')           # 删除文件
    os.rmdir('dir')                 # 删除空目录
    os.removedirs('a/b/c')          # 递归删除空目录
    os.getcwd()                     # 获取当前工作目录
    os.chdir('/tmp')                # 切换当前工作目录
    os.walk('.')                    # 遍历目录树，生成 (root, dirs, files)
    os.path.join('a', 'b')          # 连接路径（os.path 常用）
    os.path.exists('path')          # 路径是否存在
    os.environ.get('HOME')          # 访问环境变量

sys:
    import sys
    sys.argv                        # 命令行参数列表
    sys.exit(0)                     # 退出程序并返回状态码
    sys.path                        # 模块搜索路径列表
    sys.modules                     # 已加载模块字典
    sys.version                     # Python 版本信息
    sys.platform                    # 平台标识
    sys.getsizeof(obj)              # 对象占用字节数（估算）
    sys.stdin                        # 标准输入流
    sys.stdout                       # 标准输出流
    sys.stderr                       # 标准错误流
    sys.exc_info()                  # 当前异常信息 (type, value, traceback)

time:
    import time
    time.time()                     # 返回当前时间戳（浮点秒）
    time.sleep(1.0)                 # 休眠
    time.perf_counter()             # 高精度计时
    time.monotonic()                # 单调时钟（用于测量间隔）
    time.localtime()                # 时间戳 -> 本地时间 struct_time
    time.gmtime()                   # 时间戳 -> UTC 时间 struct_time
    time.strftime("%Y-%m-%d", time.localtime())  # 格式化时间为字符串
    time.strptime("2020-01-01", "%Y-%m-%d")      # 字符串解析为 struct_time
    time.ctime()                     # 可读时间字符串
    time.asctime(time.localtime())   # struct_time -> 可读字符串

datetime:
    import datetime
    datetime.datetime.now()         # 当前本地日期时间
    datetime.date.today()           # 当前日期
    datetime.datetime.utcnow()      # 当前 UTC 时间
    datetime.datetime.fromtimestamp(0)  # 时间戳 -> datetime
    datetime.datetime.strptime("2020-01-01", "%Y-%m-%d")  # 解析字符串
    datetime.datetime.strftime(datetime.datetime.now(), "%Y-%m-%d")  # 格式化
    datetime.timedelta(days=1, hours=2)  # 时间差对象
    datetime.datetime.combine(datetime.date.today(), datetime.time(12,0))  # 合并
    dt.isoformat()                  # ISO 格式字符串
    datetime.datetime.replace(year=2021)  # 替换字段生成新对象

math:
    import math
    math.sqrt(9)                    # 平方根
    math.ceil(2.3)                  # 向上取整
    math.floor(2.7)                 # 向下取整
    math.factorial(5)               # 阶乘
    math.gcd(12, 18)                # 最大公约数
    math.sin(math.pi/2)             # 正弦
    math.cos(0)                     # 余弦
    math.tan(0.5)                   # 正切
    math.log(10)                    # 自然对数
    math.pow(2, 3)                  # 幂运算（返回浮点）

random:
    import random
    random.random()                 # [0.0, 1.0) 浮点随机数
    random.randrange(0,10,2)        # 从 range 中选随机数
    random.randint(1,10)            # 包含端点的随机整数
    random.choice([1,2,3])          # 随机选择单个元素
    random.choices([1,2,3], k=2)    # 带权重可重复抽样
    random.sample(range(10), 3)     # 不重复抽样
    random.shuffle(my_list)         # 就地打乱列表
    random.seed(0)                  # 设置随机种子
    random.uniform(0,1)             # [0,1) 浮点范围
    random.getrandbits(16)          # 返回随机比特数整数

re:
    import re
    re.compile(r'\d+')              # 编译正则模式
    re.search(r'a', 'abc')          # 在字符串中搜索（任意位置）
    re.match(r'a', 'abc')           # 从开头匹配
    re.fullmatch(r'\d+', '123')     # 完全匹配
    re.findall(r'\w+', 'a b c')     # 返回所有匹配列表
    re.finditer(r'\w+', 'a b c')    # 返回迭代器，得到 Match 对象
    re.sub(r'foo', 'bar', 'foo1')   # 替换第一个/全部（默认全部）
    re.subn(r'foo', 'bar', 'foo1')  # 返回 (result, 替换次数)
    re.split(r'\s+', 'a b  c')      # 根据模式拆分字符串
    re.escape('a.b')                # 转义字符串为字面匹配

json:
    import json
    json.dumps({"a":1})             # 将对象转为 JSON 字符串
    json.loads('{"a":1}')           # JSON 字符串 -> Python 对象
    json.dump(obj, fp)              # 将对象写入文件（文本）
    json.load(fp)                   # 从文件读取并解析 JSON
    json.dumps(obj, ensure_ascii=False)  # 保持非 ascii 字符
    json.dumps(obj, indent=2)       # 美化输出
    json.loads(s, object_hook=lambda d: MyObj(**d))  # 自定义解析
    json.JSONEncoder                # 可自定义编码器基类
    json.JSONDecoder                # 可自定义解码器基类
    json.dumps(obj, separators=(',',':'))  # 紧凑格式

collections:
    from collections import defaultdict, Counter, deque, namedtuple, OrderedDict, ChainMap
    defaultdict(list)               # 带默认工厂的 dict
    Counter("abracadabra")          # 计数器
    deque([1,2,3])                  # 双端队列（高效头尾操作）
    deque.appendleft(x)             # 在左端添加
    deque.popleft()                 # 左端弹出
    namedtuple('P', ['x','y'])      # 轻量不可变记录类型
    OrderedDict()                   # 保持插入顺序的 dict（Py3.7+ dict 已默认保持）
    ChainMap(dict1, dict2)          # 将多个映射组合为单视图
    deque.rotate(1)                 # 循环移动
    Counter.most_common(3)          # 取出现频率最高的几个

functools:
    import functools
    functools.lru_cache(maxsize=128)(func)  # 缓存函数结果
    functools.partial(func, x=1)    # 固定部分参数返回新函数
    functools.reduce(lambda a,b: a+b, [1,2,3])  # 归约/累积
    functools.wraps(func)           # 装饰器中保留原函数元信息
    functools.cmp_to_key(lambda a,b: a-b)  # 旧式比较到 key
    functools.total_ordering        # 自动补全比较方法的类装饰器
    functools.singledispatch        # 基于参数类型的函数重载
    functools.update_wrapper        # 更新包装器属性
    functools.partialmethod        # 在类中定义偏函数方法（Py3.4+）
    functools.cache                 # Python3.9+ 简化版缓存装饰器（无最大缓存）

hashlib:
    import hashlib
    hashlib.md5(b'data').hexdigest()        # MD5 摘要（十六进制）
    hashlib.sha1(b'data').hexdigest()       # SHA-1 摘要
    hashlib.sha256(b'data').hexdigest()     # SHA-256 摘要
    hashlib.new('md5', b'data').hexdigest() # 动态创建算法
    h = hashlib.sha256(); h.update(b'a'); h.update(b'b'); h.hexdigest()  # 分块更新
    hashlib.algorithms_available            # 可用算法集合
    hashlib.blake2b(b'data').hexdigest()    # BLAKE2b 摘要
    hashlib.pbkdf2_hmac('sha256', b'pw', b'salt', 100000)  # 密钥派生
    h.digest()                              # 返回二进制摘要
    h.copy()                                # 复制哈希对象以并行计算

urllib (urllib.request / urllib.parse):
    from urllib import request, parse
    request.urlopen('http://example.com')   # 打开 URL（返回响应对象）
    request.Request('http://', headers={'User-Agent':'x'})  # 创建请求对象
    request.urlretrieve('http://..', 'file')  # 下载保存（简单）
    parse.urlencode({'a':1})                 # 编码查询参数
    parse.urlparse('http://a/b?x=1')         # 解析 URL 为组件
    parse.urljoin('http://a/', 'b')          # 拼接 URL
    parse.quote('a b')                       # URL 编码
    parse.unquote('a%20b')                   # URL 解码
    request.install_opener(None)             # 安装自定义 opener
    request.build_opener()                   # 构造 opener（用于添加 handler）

smtplib:
    import smtplib
    smtp = smtplib.SMTP('smtp.example.com', 25)  # 创建 SMTP 客户端（明文）
    smtp.ehlo()                                # 标准问候
    smtp.starttls()                            # 启用 TLS
    smtp.login('user','pass')                  # 登录
    smtp.sendmail('from','to','message')       # 发送邮件（简单接口）
    smtp.send_message(email_message)           # 发送 EmailMessage 对象（推荐）
    smtp.set_debuglevel(1)                     # 打印调试信息
    smtp.quit()                                # 结束会话
    smtplib.SMTP_SSL('smtp.example.com', 465)  # SSL 连接
    smtplib.SMTPException                     # 异常基类

zlib:
    import zlib
    zlib.compress(b'data')                    # 压缩字节
    zlib.decompress(zlib.compress(b'data'))   # 解压
    zlib.crc32(b'data')                       # CRC32 校验
    zlib.adler32(b'data')                     # Adler-32 校验
    zlib.compressobj(level=6)                 # 流式压缩对象
    zlib.decompressobj()                      # 流式解压对象
    zlib.ZLIB_VERSION                          # zlib 版本
    zlib.error                                # 异常类型
    c = zlib.compress(b'')                    # 可空压缩结果
    zlib.MAX_WBITS                             # 配置常量（用于 gzip/zip 等）

gzip:
    import gzip
    gzip.compress(b'data')                    # 压缩为 gzip bytes
    gzip.decompress(gzip.compress(b'data'))   # 解压 gzip bytes
    gzip.open('f.gz', 'wb')                   # 以 gzip 方式打开文件（二进制）
    with gzip.open('f.gz', 'rt', encoding='utf-8') as f: pass  # 文本模式
    gzip.GzipFile(filename='f.gz')            # GzipFile 对象
    gzip.compress(b'data', compresslevel=9)   # 指定压缩级别
    gzip.decompressobj()                      # 可选流式解压（少用）
    gzip.OPEN = gzip.open                      # 兼容别名
    gzip.BadGzipFile                           # 异常类型
    gzip.compress(b'')                        # 空内容也可压缩

bz2:
    import bz2
    bz2.compress(b'data')                     # bzip2 压缩
    bz2.decompress(bz2.compress(b'data'))     # bzip2 解压
    bz2.BZ2File('f.bz2', 'wb')                # 文件接口（写）
    with bz2.open('f.bz2', 'rt') as f: pass   # 打开为文本模式
    bz2.BZ2Compressor()                        # 流式压缩
    bz2.BZ2Decompressor()                      # 流式解压
    bz2.compress(b'', compresslevel=9)        # 指定级别（接口可能受限）
    bz2.open('f.bz2', 'rb')                   # 二进制读取
    bz2.error                                 # 异常类型
    bz2.decompressobj = None                  # 占位（兼容说明）

multiprocessing:
    import multiprocessing as mp
    mp.Process(target=func, args=(1,)).start()  # 启动新进程
    mp.Pool(processes=4).map(func, data)       # 进程池并行 map
    mp.Queue()                                 # 进程间队列
    mp.Manager().dict()                        # 共享字典（通过 manager）
    mp.Value('i', 0)                           # 共享单值
    mp.Array('i', [1,2,3])                     # 共享数组
    mp.Lock()                                  # 进程同步锁
    mp.cpu_count()                             # CPU 核心数
    mp.current_process()                       # 当前进程信息
    mp.freeze_support()                         # Windows 打包支持函数

threading:
    import threading
    t = threading.Thread(target=func); t.start()  # 启动线程
    threading.Lock()                            # 互斥锁
    threading.RLock()                           # 可重入锁
    threading.Event()                           # 线程间事件通信
    threading.Timer(1.0, func).start()          # 定时执行线程
    threading.Semaphore(2)                      # 信号量
    threading.current_thread()                  # 当前线程对象
    threading.active_count()                    # 活跃线程数
    threading.enumerate()                       # 列出活跃线程
    threading.local()                           # 线程本地数据

copy:
    import copy
    copy.copy(obj)                              # 浅拷贝（引用内嵌对象）
    copy.deepcopy(obj)                          # 深拷贝（递归复制）
    c = obj.__copy__ if hasattr(obj,'__copy__') else None  # 自定义拷贝协议检查
    copy.copy([1,2,3])                          # 列表浅拷贝示例
    copy.deepcopy({'a':[1,2]})                  # 深拷贝示例
    # copy 模块无很多方法，重点在 copy & deepcopy 及自定义拷贝协议

socket:
    import socket
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 创建 TCP socket
    s.bind(('0.0.0.0', 8000))                # 绑定地址
    s.listen(5)                              # 监听连接
    conn, addr = s.accept()                  # 接受连接
    s.connect(('example.com', 80))           # 客户端连接
    s.send(b'GET / HTTP/1.0\r\n\r\n')        # 发送数据
    s.recv(4096)                             # 接收数据
    socket.create_connection(('example.com', 80), timeout=5)  # 便捷连接
    socket.gethostbyname('localhost')        # DNS 解析示例
    s.close()                                # 关闭 socket

shutil:
    import shutil
    shutil.copy('src', 'dst')                # 复制文件（内容）
    shutil.copy2('src', 'dst')               # 复制并尽量保留元数据
    shutil.copyfile('src', 'dst')            # 复制文件（必须为文件）
    shutil.copytree('srcdir', 'dstdir')      # 复制目录树
    shutil.rmtree('dstdir')                  # 删除目录树
    shutil.move('src', 'dst')                # 移动/重命名
    shutil.make_archive('base', 'zip', 'dir')# 打包成压缩包
    shutil.unpack_archive('base.zip', 'outdir')  # 解压归档
    shutil.disk_usage('/')                    # 磁盘使用信息 (total, used, free)
    shutil.which('python')                    # 查找可执行文件路径

glob:
    import glob
    glob.glob('*.py')                         # 列出匹配的文件（列表）
    glob.iglob('**/*.py', recursive=True)     # 生成器模式，按需产生结果
    glob.escape('a[b]*')                      # 转义模式字符
    glob.has_magic('*.py')                    # 模式是否包含通配符
    # 常与 fnmatch 配合使用来做更复杂匹配
    # glob 模式示例： '*.txt', 'data/*.csv', '**/tests/*.py'（recursive=True 时 ** 表示任意深度）
"""